//! Abstract syntax tree types for mangled symbols.

use super::{DemangleNodeType, DemangleOptions, DemangleWrite, ParseOptions};

use boxed::Box;

use error::{self, Result};

use index_str::IndexStr;

use std::cell::Cell;

#[cfg(feature = "logging")]

use std::cell::RefCell;

use std::fmt::{self, Write};

use std::hash::{Hash, Hasher};

use std::mem;

use std::ops;

use std::ptr;

use string::String;

use subs::{Substitutable, SubstitutionTable};

use vec::Vec;

struct AutoLogParse;

#[cfg(feature = "logging")]

thread_local! {

    static LOG_DEPTH: RefCell<usize> = RefCell::new(0);

}

impl AutoLogParse {

    #[cfg(feature = "logging")]

    fn new(production: &'static str, input: IndexStr<'_>) -> AutoLogParse {

        LOG_DEPTH.with(|depth| {

            if *depth.borrow() == 0 {

                println!();

            }

            let indent: String = (0..*depth.borrow() * 4).map(|_| ' ').collect();

            log!(

                "{}({} \"{}\" {}",

                indent,

                production,

                String::from_utf8_lossy(input.as_ref()),

                input.len(),

            );

            *depth.borrow_mut() += 1;

        });

        AutoLogParse

    }

    #[cfg(not(feature = "logging"))]

    #[inline(always)]

}

#[cfg(feature = "logging")]

impl Drop for AutoLogParse {

    fn drop(&mut self) {

        LOG_DEPTH.with(|depth| {

            *depth.borrow_mut() -= 1;

            let indent: String = (0..*depth.borrow() * 4).map(|_| ' ').collect();

            log!("{})", indent);

        });

    }

}

/// Performs the two operations that begin every parse:

///

/// 1. Keeps track of recursion levels and early returns with an error if there

///    is too much recursion.

///

/// 2. Automatically log start and end parsing in an s-expression format, when the

///    `logging` feature is enabled.

macro_rules! try_begin_parse {

    ( $production:expr , $ctx:expr , $input:expr ) => {

        let _log = AutoLogParse::new($production, $input);

        let _auto_check_recursion = AutoParseRecursion::new($ctx)?;

    };

}

struct AutoLogDemangle;

impl AutoLogDemangle {

    #[cfg(feature = "logging")]

    fn new<P, W>(

        production: &P,

        ctx: &DemangleContext<W>,

        scope: Option<ArgScopeStack>,

        is_inner: bool,

    ) -> AutoLogDemangle

    where

        P: ?Sized + fmt::Debug,

        W: DemangleWrite,

    {

        LOG_DEPTH.with(|depth| {

            if *depth.borrow() == 0 {

                println!();

            }

            let indent: String = (0..*depth.borrow() * 4).map(|_| ' ').collect();

            log!("{}(", indent);

            log!(

                "{}  {}{:?}",

                indent,

                if is_inner { "as_inner: " } else { "" },

                production

            );

            log!("{}  inner = {:?}", indent, ctx.inner);

            log!("{}  scope = {:?}", indent, scope);

            *depth.borrow_mut() += 1;

        });

        AutoLogDemangle

    }

    #[cfg(not(feature = "logging"))]

    #[inline(always)]

}

#[cfg(feature = "logging")]

impl Drop for AutoLogDemangle {

    fn drop(&mut self) {

        LOG_DEPTH.with(|depth| {

            *depth.borrow_mut() -= 1;

            let indent: String = (0..*depth.borrow() * 4).map(|_| ' ').collect();

            log!("{})", indent);

        });

    }

}

/// Automatically log start and end demangling in an s-expression format, when

/// the `logging` feature is enabled.

macro_rules! try_begin_demangle {

    ( $production:expr, $ctx:expr, $scope:expr ) => {{

        let _log = AutoLogDemangle::new($production, $ctx, $scope, false);

        &mut AutoParseDemangle::new($ctx)?

    }};

}

/// Automatically log start and end demangling in an s-expression format, when

/// the `logging` feature is enabled.

macro_rules! try_begin_demangle_as_inner {

    ( $production:expr, $ctx:expr, $scope:expr ) => {{

        let _log = AutoLogDemangle::new($production, $ctx, $scope, true);

        &mut AutoParseDemangle::new($ctx)?

    }};

}

#[derive(Debug, Default, Clone, Copy)]

struct ParseContextState {

    // The current recursion level. Should always be less than or equal to the

    // maximum.

    recursion_level: u32,

    // Whether or not we are currently parsing a conversion operator.

    in_conversion: bool,

}

/// Common context needed when parsing.

#[derive(Debug, Clone)]

pub struct ParseContext {

    // Maximum amount of recursive parsing calls we will allow. If this is too

    // large, we can blow the stack.

    max_recursion: u32,

    // Mutable state within the `ParseContext`.

    state: Cell<ParseContextState>,

}

impl ParseContext {

    /// Construct a new `ParseContext`.

    /// Get the current recursion level for this context.

    #[inline]

        } else {

        }

    #[inline]

    #[inline]

}

/// An RAII type to automatically check the recursion level against the

/// maximum. If the maximum has been crossed, return an error. Otherwise,

/// increment the level upon construction, and decrement it upon destruction.

struct AutoParseRecursion<'a>(&'a ParseContext);

impl<'a> AutoParseRecursion<'a> {

    #[inline]

}

impl<'a> Drop for AutoParseRecursion<'a> {

    #[inline]

}

/// A trait for anything that can be parsed from an `IndexStr` and return a

/// `Result` of the parsed `Self` value and the rest of the `IndexStr` input

/// that has not been consumed in parsing the `Self` value.

///

/// For AST types representing productions which have `<substitution>` as a

/// possible right hand side, do not implement this trait directly. Instead,

/// make a newtype over `usize`, parse either the `<substitution>` back

/// reference or "real" value, insert the "real" value into the substitution

/// table if needed, and *always* return the newtype index into the substitution

/// table.

#[doc(hidden)]

pub trait Parse: Sized {

    /// Parse the `Self` value from `input` and return it, updating the

    /// substitution table as needed.

    fn parse<'a, 'b>(

        ctx: &'a ParseContext,

        subs: &'a mut SubstitutionTable,

        input: IndexStr<'b>,

    ) -> Result<(Self, IndexStr<'b>)>;

}

/// Determine whether this AST node is an instantiated[*] template function, and

/// get its concrete template arguments.

///

/// [*] Note that we will never see an abstract, un-instantiated template

/// function, since they don't end up in object files and don't get mangled

/// names.

trait GetTemplateArgs {

    /// Returns `Some` if this is a template function, `None` otherwise.

    fn get_template_args<'a>(&'a self, subs: &'a SubstitutionTable) -> Option<&'a TemplateArgs>;

}

/// A leaf name is the part the name that describes some type or class without

/// any leading namespace qualifiers.

///

/// This is used when figuring out how to format constructors and destructors,

/// which are formatted as `gooble::dodo::Thing::~Thing()` but we don't have

/// direct access to `Thing` in the `CtorDtorName` AST.

#[derive(Debug)]

pub(crate) enum LeafName<'a> {

    SourceName(&'a SourceName),

    WellKnownComponent(&'a WellKnownComponent),

    Closure(&'a ClosureTypeName),

    UnnamedType(&'a UnnamedTypeName),

}

impl<'subs, W> DemangleAsLeaf<'subs, W> for LeafName<'subs>

where

    W: 'subs + DemangleWrite,

{

        }

}

/// Determine whether this AST node is some kind (potentially namespaced) name

/// and if so get its leaf name.

pub(crate) trait GetLeafName<'a> {

    fn get_leaf_name(&'a self, subs: &'a SubstitutionTable) -> Option<LeafName<'a>>;

}

/// Determine whether this AST node is a constructor, destructor, or conversion

/// function.

pub(crate) trait IsCtorDtorConversion {

    fn is_ctor_dtor_conversion(&self, subs: &SubstitutionTable) -> bool;

}

/// When formatting a mangled symbol's parsed AST as a demangled symbol, we need

/// to resolve indirect references to template and function arguments with

/// direct `TemplateArg` and `Type` references respectively.

///

/// Note that which set of arguments are implicitly referenced change as we

/// enter and leave different functions' scope. One might usually use de Brujin

/// indices to keep arguments within scopes separated from each other, but the

/// Itanium C++ ABI does not allow us the luxury. AFAIK, when the ABI was first

/// drafted, C++ did not have lambdas, and the issue did not come up at all

/// since a function simply couldn't refer to the types of closed over

/// variables.

///

/// This trait is implemented by anything that can potentially resolve arguments

/// for us.

trait ArgScope<'me, 'ctx>: fmt::Debug {

    /// Get the current scope's leaf name.

    fn leaf_name(&'me self) -> Result<LeafName<'ctx>>;

    /// Get the current scope's `index`th template argument.

    fn get_template_arg(&'me self, index: usize)

        -> Result<(&'ctx TemplateArg, &'ctx TemplateArgs)>;

    /// Get the current scope's `index`th function argument's type.

    fn get_function_arg(&'me self, index: usize) -> Result<&'ctx Type>;

}

/// An `ArgScopeStack` represents the current function and template demangling

/// scope we are within. As we enter new demangling scopes, we construct new

/// `ArgScopeStack`s whose `prev` references point back to the old ones. These

/// `ArgScopeStack`s are kept on the native stack, and as functions return, they

/// go out of scope and we use the previous `ArgScopeStack`s again.

#[derive(Copy, Clone, Debug)]

pub struct ArgScopeStack<'prev, 'subs>

where

    'subs: 'prev,

{

    item: &'subs dyn ArgScope<'subs, 'subs>,

    in_arg: Option<(usize, &'subs TemplateArgs)>,

    prev: Option<&'prev ArgScopeStack<'prev, 'subs>>,

}

/// When we first begin demangling, we haven't entered any function or template

/// demangling scope and we don't have any useful `ArgScopeStack`. Therefore, we

/// are never actually dealing with `ArgScopeStack` directly in practice, but

/// always an `Option<ArgScopeStack>` instead. Nevertheless, we want to define

/// useful methods on `Option<ArgScopeStack>`.

///

/// A custom "extension" trait with exactly one implementor: Rust's principled

/// monkey patching!

trait ArgScopeStackExt<'prev, 'subs>: Copy {

    /// Push a new `ArgScope` onto this `ArgScopeStack` and return the new

    /// `ArgScopeStack` with the pushed resolver on top.

    fn push(

        &'prev self,

        item: &'subs dyn ArgScope<'subs, 'subs>,

    ) -> Option<ArgScopeStack<'prev, 'subs>>;

}

impl<'prev, 'subs> ArgScopeStackExt<'prev, 'subs> for Option<ArgScopeStack<'prev, 'subs>> {

}

/// A stack of `ArgScope`s is itself an `ArgScope`!

impl<'prev, 'subs> ArgScope<'prev, 'subs> for Option<ArgScopeStack<'prev, 'subs>> {

        }

                    {

        }

        }

}

#[derive(Debug, Copy, Clone)]

struct DemangleState {

    /// How deep in the demangling are we?

    pub recursion_level: u32,

}

/// An RAII type to automatically check the recursion level against the

/// maximum. If the maximum has been crossed, return an error. Otherwise,

/// increment the level upon construction, and decrement it upon destruction.

struct AutoParseDemangle<'a, 'b, W: 'a + DemangleWrite>(&'b mut DemangleContext<'a, W>);

impl<'a, 'b, W: 'a + DemangleWrite> AutoParseDemangle<'a, 'b, W> {

    #[inline]

}

impl<'a, 'b, W: 'a + DemangleWrite> std::ops::Deref for AutoParseDemangle<'a, 'b, W> {

    type Target = DemangleContext<'a, W>;

}

impl<'a, 'b, W: 'a + DemangleWrite> std::ops::DerefMut for AutoParseDemangle<'a, 'b, W> {

}

impl<'a, 'b, W: 'a + DemangleWrite> Drop for AutoParseDemangle<'a, 'b, W> {

    #[inline]

}

/// Common state that is required when demangling a mangled symbol's parsed AST.

#[doc(hidden)]

#[derive(Debug)]

pub struct DemangleContext<'a, W>

where

    W: 'a + DemangleWrite,

{

    // The substitution table built up when parsing the mangled symbol into an

    // AST.

    subs: &'a SubstitutionTable,

    // The maximum recursion

    max_recursion: u32,

    // Sometimes an AST node needs to insert itself as an inner item within one

    // of its children when demangling that child. For example, the AST

    //

    //     (array 10 int)

    //

    // is demangled as `int[10]`, but if we were to demangle the AST

    //

    //     (lvalue-ref (array 10 int))

    //

    // then we would want this demangled form: `int (&) [10]`, which requires

    // the parent lvalue-ref to be passed into the child array's demangling

    // method. This kind of thing also pops up with function pointers.

    //

    // The `inner` stack enables such behavior by allowing us to pass AST

    // parents down to their children as inner items.

    inner: Vec<&'a dyn DemangleAsInner<'a, W>>,

    // The original input string.

    input: &'a [u8],

    // `Identifier`s will be placed here, so `UnnamedTypeName` can utilize and print

    // out the Constructor/Destructor used.

    source_name: Option<&'a str>,

    // What the demangled name is being written to.

    out: &'a mut W,

    // The total number of bytes written to `out`. This is maintained by the

    // `Write` implementation for `DemangleContext`.

    bytes_written: usize,

    // The last char written to `out`, if any.

    last_char_written: Option<char>,

    // We are currently demangling a lambda argument, so template substitution

    // should be suppressed to match libiberty.

    is_lambda_arg: bool,

    // We are currently demangling a template-prefix.

    is_template_prefix: bool,

    // We are currently demangling a template-prefix in a nested-name.

    is_template_prefix_in_nested_name: bool,

    //  `PackExpansion`'s should only print '...', only when there is no template

    //  argument pack.

    is_template_argument_pack: bool,

    // Whether to show function parameters.

    // This must be set to true before calling `demangle` on `Encoding`

    // unless that call is via the toplevel call to `MangledName::demangle`.

    show_params: bool,

    // Whether to show function return types.

    // This must be set to true before calling `demangle` on `Encoding`

    // unless that call is via the toplevel call to `MangledName::demangle`.

    show_return_type: bool,

    // Whether to show types of expression literals.

    show_expression_literal_types: bool,

    // recursion protection.

    state: Cell<DemangleState>,

}

impl<'a, W> fmt::Write for DemangleContext<'a, W>

where

    W: 'a + DemangleWrite,

{

}

impl<'a, W> DemangleContext<'a, W>

where

    W: 'a + DemangleWrite,

{

    /// Construct a new `DemangleContext`.

    /// Get the current recursion level for this context.

    #[inline]

        } else {

        }

    #[inline]

    #[inline]

        } else {

        }

    #[inline]

    #[inline]

    #[inline]

    #[inline]

        } else {

        }

            {

                    inner

                );

            } else {

                    inner

                );

            }

        }

        }

    /// This should not be called on error paths.

    /// pop_inner_if already doesn't balance if there are errors.

}

#[doc(hidden)]

#[derive(Debug)]

pub struct AutoDemangleContextInnerBarrier<'ctx, 'a, W>

where

    W: 'a + DemangleWrite,

    'a: 'ctx,

{

    ctx: &'ctx mut DemangleContext<'a, W>,

    saved_inner: Vec<&'a dyn DemangleAsInner<'a, W>>,

}

impl<'ctx, 'a, W> AutoDemangleContextInnerBarrier<'ctx, 'a, W>

where

    W: 'a + DemangleWrite,

    'a: 'ctx,

{

    /// Set aside the current inner stack on the demangle context.

}

impl<'ctx, 'a, W> ops::Deref for AutoDemangleContextInnerBarrier<'ctx, 'a, W>

where

    W: 'a + DemangleWrite,

    'a: 'ctx,

{

    type Target = DemangleContext<'a, W>;

}

impl<'ctx, 'a, W> ops::DerefMut for AutoDemangleContextInnerBarrier<'ctx, 'a, W>

where

    W: 'a + DemangleWrite,

    'a: 'ctx,

{

}

impl<'ctx, 'a, W> Drop for AutoDemangleContextInnerBarrier<'ctx, 'a, W>

where

    W: 'a + DemangleWrite,

    'a: 'ctx,

{

}

/// The inner stack allows passing AST nodes down deeper into the tree so that

/// nodes that logically precede something (e.g. PointerRef) can show up after

/// that thing in the demangled output. What's on the stack may not always be

/// intended for the first node that looks at the stack to grab, though.

///

/// Consider a function with template arguments and parameters, f<T>(a).

/// The function parameters logically precede the template arguments in the AST,

/// but they must be reversed in the output. The parameters end up on the inner

/// stack before processing the template argument nodes. If we're not careful,

/// a node inside the template arguments might pick the function parameters

/// off of the inner stack!

///

/// To solve this, certain nodes act as "inner barriers". By using this macro,

/// they set the existing inner stack aside and replace it with an empty stack

/// while visiting their children. This allows these barrier nodes to have

/// completely self-contained children.

macro_rules! inner_barrier {

    ( $ctx:ident ) => {

        let mut _ctx = AutoDemangleContextInnerBarrier::new($ctx);

        let $ctx = &mut _ctx;

    };

}

/// Any AST node that can be printed in a demangled form.

#[doc(hidden)]

pub trait Demangle<'subs, W>: fmt::Debug

where

    W: 'subs + DemangleWrite,

{

    /// Write the demangled form of this AST node to the given context.

    fn demangle<'prev, 'ctx>(

        &'subs self,

        ctx: &'ctx mut DemangleContext<'subs, W>,

        scope: Option<ArgScopeStack<'prev, 'subs>>,

    ) -> fmt::Result;

}

/// Any AST node that can be printed as an inner type.

///

/// See the comments surrounding `DemangleContext::inner` for details.

#[doc(hidden)]

pub trait DemangleAsInner<'subs, W>: Demangle<'subs, W>

where

    W: 'subs + DemangleWrite,

{

    /// Write the inner demangling form of this AST node to the given context.

    /// Cast this `DemangleAsInner` to a `Type`.

    /// Cast this `DemangleAsInner` to a `FunctionType`.

    /// Cast this `DemangleAsInner` to an `ArrayType`.

    /// Cast this `DemangleAsInner` to a `PointerToMember`.

}

/// Demangle this thing in the leaf name position.

///

/// For most things this should be the same as its `Demangle`

/// implementation. For `WellKnownComponent`s we need to strip the embedded

/// `std::` namespace prefix.

pub(crate) trait DemangleAsLeaf<'subs, W>

where

    W: 'subs + DemangleWrite,

{

    fn demangle_as_leaf<'me, 'ctx>(

        &'me self,

        ctx: &'ctx mut DemangleContext<'subs, W>,

    ) -> fmt::Result;

}

macro_rules! reference_newtype {

    ( $newtype_name:ident , $oldtype:ty ) => {

        #[derive(Debug)]

        struct $newtype_name($oldtype);

        impl $newtype_name {

            #[allow(clippy::ptr_arg)]

            #[allow(unsafe_code)]

        }

        impl Drop for $newtype_name {

            }

        }

        impl ops::Deref for $newtype_name {

            type Target = $oldtype;

        }

    };

}

// We can't implement `DemangleAsInner` for newtypes of `[TypeHandle]` like we

// want to because it is unsized and we need to make trait objects out of

// `DemangleAsInner` for pushing onto the context's inner stack. Therefore, we

// have this inelegant newtyping of `Vec<TypeHandle>`.

// A set of function arguments.

reference_newtype!(FunctionArgList, Vec<TypeHandle>);

// A set of function arguments prefixed by a return type (which we want to

// ignore).

reference_newtype!(FunctionArgListAndReturnType, Vec<TypeHandle>);

// A newtype around a slice of type handles that we format as function

// arguments.

reference_newtype!(FunctionArgSlice, [TypeHandle]);

// Demangle a slice of TypeHandle as a function argument list.

impl<'subs, W> Demangle<'subs, W> for FunctionArgSlice

where

    W: 'subs + DemangleWrite,

{

                } else {

                        Some(&Type::Qualified(..))

                        | Some(&Type::Complex(_))

                        | Some(&Type::Imaginary(_))

                        Some(&Type::PointerTo(_))

                        | Some(&Type::LvalueRef(_))

                    }

                }

                } else {

                }

                };

        // To maintain compatibility with libiberty, print `()` instead of

        // `(void)` for functions that take no arguments.

        }

}

impl<'subs, W> Demangle<'subs, W> for FunctionArgList

where

    W: 'subs + DemangleWrite,

{

}

impl<'subs, W> DemangleAsInner<'subs, W> for FunctionArgList where W: 'subs + DemangleWrite {}

impl<'subs, W> Demangle<'subs, W> for FunctionArgListAndReturnType

where

    W: 'subs + DemangleWrite,

{

}

impl<'subs, W> DemangleAsInner<'subs, W> for FunctionArgListAndReturnType where

    W: 'subs + DemangleWrite

{

}

/// Define a handle to a AST type that lives inside the substitution table. A

/// handle is always either an index into the substitution table, or it is a

/// reference to a "well-known" component.

///

/// This declares:

///

/// - The enum of either a back reference into the substitution table or a

///   reference to a "well-known" component

/// - a `Demangle` impl that proxies to the appropriate `Substitutable` in the

///   `SubstitutionTable`

macro_rules! define_handle {

    (

        $(#[$attr:meta])*

        pub enum $typename:ident

    ) => {

        define_handle! {

            $(#[$attr])*

            pub enum $typename {}

        }

    };

    (

        $(#[$attr:meta])*

        pub enum $typename:ident {

            $(

                $( #[$extra_attr:meta] )*

                extra $extra_variant:ident ( $extra_variant_ty:ty ),

            )*

        }

    ) => {

        $(#[$attr])*

        #[derive(Clone, Debug, PartialEq, Eq)]

        pub enum $typename {

            /// A reference to a "well-known" component.

            WellKnown(WellKnownComponent),

            /// A back-reference into the substitution table to a component we

            /// have already parsed.

            BackReference(usize),

            $(

                $( #[$extra_attr] )*

                $extra_variant( $extra_variant_ty ),

            )*

        }

        impl $typename {

            /// If this is a `BackReference`, get its index.

                }

        }

        impl<'subs, W> Demangle<'subs, W> for $typename

        where

            W: 'subs + DemangleWrite

        {

            #[inline]

                    $(

                    )*

                }

        }

        impl<'a> GetLeafName<'a> for $typename {

                    }

                    $(

                    )*

                }

        }

    };

}

/// A handle to a component that is usually substitutable, and lives in the

/// substitutions table, but in this particular case does not qualify for

/// substitutions.

#[derive(Clone, Debug, PartialEq, Eq)]

pub struct NonSubstitution(usize);

impl<'subs, W> Demangle<'subs, W> for NonSubstitution

where

    W: 'subs + DemangleWrite,

{

}

impl<'a> GetLeafName<'a> for NonSubstitution {

}

/// Define a "vocabulary" nonterminal, something like `OperatorName` or

/// `CtorDtorName` that's basically a big list of constant strings.

///

/// This declares:

///

/// - the enum itself

/// - a `Parse` impl

/// - a `Demangle` impl

///

/// See the definition of `CTorDtorName` for an example of its use.

///

/// Optionally, a piece of user data can be attached to the definitions

/// and be returned by a generated accessor. See `SimpleOperatorName` for

/// an example.

macro_rules! define_vocabulary {

    ( $(#[$attr:meta])* pub enum $typename:ident {

        $($variant:ident ( $mangled:expr, $printable:expr )),*

    } ) => {

        $(#[$attr])*

        pub enum $typename {

            $(

                #[doc=$printable]

                $variant

            ),*

        }

        impl Parse for $typename {

                $(

                    } else {

                    }

                )*

                } else {

                }

        }

        impl<'subs, W> Demangle<'subs, W> for $typename

        where

            W: 'subs + DemangleWrite,

        {

        }

        impl $typename {

            #[allow(dead_code)]

            #[inline]

                $(

        }

    };

    ( $(#[$attr:meta])* pub enum $typename:ident {

        $($variant:ident ( $mangled:expr, $printable:expr, $userdata:expr)),*

    }

      impl $typename2:ident {

          fn $fn_name:ident(&self) -> $userdata_ty:ty;

    } ) => {

        define_vocabulary! {

            $(#[$attr])*

            pub enum $typename {

                $(

                    $variant ( $mangled, $printable )

                ),*

            }

        }

        impl $typename2 {

                    $(

                        $typename2::$variant => $userdata,

                    )*

                }

        }

    };

}

/// The root AST node, and starting production.

///

/// ```text

/// <mangled-name> ::= _Z <encoding> [<clone-suffix>]*

///                ::= ___Z <encoding> <block_invoke>

///                ::= <type>

///

/// <block_invoke> ::= _block_invoke

///                ::= _block_invoke<decimal-digit>+

///                ::= _block_invoke_<decimal-digit>+

/// ```

#[derive(Clone, Debug, PartialEq, Eq)]

pub enum MangledName {

    /// The encoding of the mangled symbol name.

    Encoding(Encoding, Vec<CloneSuffix>),

    /// The encoding of the mangled symbol name.

    BlockInvoke(Encoding, Option<isize>),

    /// A top-level type. Technically not allowed by the standard, however in

    /// practice this can happen, and is tested for by libiberty.

    Type(TypeHandle),

    /// A global constructor or destructor. This is another de facto standard

    /// extension (I think originally from `g++`?) that is not actually part of

    /// the standard proper.